Dec15, 2025

Cómo integrar Camoufox con CapSolver para la resolución de CAPTCHA sin interrupciones

Aloísio Vítor

Image Processing Expert

TL;DR: Usa Camoufox para evitar el fingerprinting del navegador y CapSolver para resolver automáticamente los CAPTCHAs como Cloudflare Turnstile y reCAPTCHA v2/v3. Juntos, permiten la automatización web estable y con comportamiento humano a escala con mínima detección y altas tasas de éxito.

Introducción

La automatización web se ha vuelto esencial para la recopilación de datos, pruebas y diversas operaciones empresariales. Sin embargo, los sitios web modernos implementan medidas anti-bot y CAPTCHAs sofisticados que pueden detener incluso los scripts de automatización más cuidadosamente elaborados.

La combinación de Camoufox y CapSolver proporciona una solución poderosa para este desafío:

Camoufox: Un navegador anti-detección de código abierto basado en Firefox que evita la detección de bots mediante un spoofing avanzado de fingerprinting
CapSolver: Un servicio de resolución de CAPTCHA impulsado por inteligencia artificial que maneja Cloudflare Turnstile, reCAPTCHA y más

Juntos, estos herramientas permiten una automatización web fluida que evita tanto la detección de fingerprinting como los desafíos de CAPTCHA.

Objetivos de la integración

Este guía te ayudará a lograr tres objetivos principales:

Evitar la detección de bots - Usa la inyección de fingerprinting de Camoufox para parecer un navegador legítimo
Resolver CAPTCHAs automáticamente - Integra la API de CapSolver para manejar desafíos de CAPTCHA sin intervención manual
Mantener un comportamiento similar al humano - Combina movimientos de mouse humanizados con resolución inteligente de CAPTCHAs

¿Qué es Camoufox?

Camoufox es una versión personalizada minimalista de Firefox diseñada específicamente para scraping y automatización web. A diferencia de otras soluciones anti-detección que dependen de la inyección de JavaScript (que puede ser detectada), Camoufox implementa el spoofing de fingerprinting a nivel de C++ dentro del navegador mismo.

Características clave

Inyección de fingerprinting - Spoofea propiedades de navigator, dimensiones de pantalla, WebGL, WebRTC, fuentes, etc., a nivel nativo
Movimiento de mouse similar al humano - Algoritmo integrado para interacciones realistas
Integración con BrowserForge - Genera fingerprints que imitan distribuciones de dispositivos del mundo real
Soporte GeoIP - Calcula automáticamente zona horaria, configuración regional y geolocalización basado en la IP del proxy
Soporte para complementos de Firefox - Carga extensiones personalizadas incluyendo bloqueadores de anuncios

Instalación

bash Copy

# Instalar el paquete de Python
pip install -U camoufox[geoip]

# Descargar el navegador Camoufox
camoufox fetch

Uso básico

python Copy

from camoufox.sync_api import Camoufox

with Camoufox(humanize=True) as browser:
    page = browser.new_page()
    page.goto("https://example.com")

¿Qué es CapSolver?

CapSolver es un servicio de resolución automática de CAPTCHA impulsado por inteligencia artificial que soporta una amplia gama de tipos de CAPTCHA. Proporciona una API sencilla que te permite enviar desafíos de CAPTCHA y recibir soluciones en segundos.

Tipos de CAPTCHA soportados

Cloudflare Turnstile - El desafío anti-bot más común en la actualidad
reCAPTCHA v2 - Variantes basadas en imágenes e invisibles
reCAPTCHA v3 - Verificación basada en puntuación
AWS WAF - CAPTCHA de Amazon Web Services
Y muchos más...

Comenzar con CapSolver

Regístrese en capsolver.com
Agregue fondos a su cuenta
Obtenga su clave de API desde el panel de control

Bonus: Use el código CAMOUFOX al registrarse para recibir créditos adicionales!

Desafíos previos a la integración

Antes de combinar Camoufox con CapSolver, la automatización web enfrentaba varios problemas:

Desafío	Impacto
Detección de fingerprinting de navegador	Los scripts se bloqueaban antes de llegar al contenido
Desafíos de CAPTCHA	Se requería resolución manual, interrumpiendo la automatización
Sistemas de reputación de IP	Los proxies se marcaban y prohibían rápidamente
Análisis de comportamiento	Patrones no humanos detectados

La integración de Camoufox + CapSolver resuelve todos estos desafíos en un solo flujo de trabajo.

Métodos de integración

Método 1: Integración de API (Recomendado)

El enfoque de integración de API te da control total sobre el proceso de resolución de CAPTCHA y funciona con cualquier tipo de CAPTCHA.

Requisitos de configuración

bash Copy

pip install camoufox[geoip] httpx

Patrón de integración principal

python Copy

import asyncio
import httpx
from camoufox.async_api import AsyncCamoufox

CAPSOLVER_API_KEY = "SU_CLAVE_DE_API"
CAPSOLVER_API = "https://api.capsolver.com"


async def create_task(task_payload: dict) -> str:
    """Crear una tarea de resolución de CAPTCHA y devolver el ID de la tarea."""
    async with httpx.AsyncClient() as client:
        response = await client.post(
            f"{CAPSOLVER_API}/createTask",
            json={
                "clientKey": CAPSOLVER_API_KEY,
                "task": task_payload
            }
        )
        result = response.json()
        if result.get("errorId") != 0:
            raise Exception(f"Error de CapSolver: {result.get('errorDescription')}")
        return result["taskId"]


async def get_task_result(task_id: str, max_attempts: int = 120) -> dict:
    """Esperar el resultado de la tarea hasta que se resuelva o se agote el tiempo."""
    async with httpx.AsyncClient() as client:
        for _ in range(max_attempts):
            response = await client.post(
                f"{CAPSOLVER_API}/getTaskResult",
                json={
                    "clientKey": CAPSOLVER_API_KEY,
                    "taskId": task_id
                }
            )
            result = response.json()

            if result.get("status") == "ready":
                return result["solution"]
            elif result.get("status") == "failed":
                raise Exception(f"Tarea fallida: {result.get('errorDescription')}")

            await asyncio.sleep(1)

    raise TimeoutError("La resolución de CAPTCHA expiró")


async def solve_captcha(task_payload: dict) -> dict:
    """Completar el flujo de resolución de CAPTCHA."""
    task_id = await create_task(task_payload)
    return await get_task_result(task_id)

Método 2: Extensión del navegador

También puedes usar la extensión de CapSolver con Camoufox para un enfoque más pasivo.

Pasos de instalación

Descargue la extensión de CapSolver desde capsolver.com/en/extension
Extraiga los archivos de la extensión
Cargue la extensión en Camoufox:

python Copy

from camoufox.sync_api import Camoufox

with Camoufox(
    addons=["/ruta/a/la-extensión-capsolver"],
    headless=False  # Las extensiones requieren modo con interfaz
) as browser:
    page = browser.new_page()
    # La extensión detectará y resolverá automáticamente los CAPTCHAs

Ejemplos de código

Ejemplo 1: Resolver Cloudflare Turnstile

Cloudflare Turnstile es uno de los desafíos de CAPTCHA más comunes. Así es como lo resuelves:

python Copy

import asyncio
from camoufox.async_api import AsyncCamoufox

CAPSOLVER_API_KEY = "SU_CLAVE_DE_API"
CAPSOLVER_API = "https://api.capsolver.com"


async def solve_turnstile(site_key: str, page_url: str) -> str:
    """Resolver Cloudflare Turnstile y devolver el token."""
    import httpx

    async with httpx.AsyncClient() as client:
        # Crear la tarea
        response = await client.post(
            f"{CAPSOLVER_API}/createTask",
            json={
                "clientKey": CAPSOLVER_API_KEY,
                "task": {
                    "type": "AntiTurnstileTaskProxyLess",
                    "websiteURL": page_url,
                    "websiteKey": site_key,
                }
            }
        )
        task_id = response.json()["taskId"]

        # Esperar el resultado
        while True:
            result = await client.post(
                f"{CAPSOLVER_API}/getTaskResult",
                json={
                    "clientKey": CAPSOLVER_API_KEY,
                    "taskId": task_id
                }
            )
            data = result.json()

            if data.get("status") == "ready":
                return data["solution"]["token"]

            await asyncio.sleep(1)


async def main():
    target_url = "https://example.com/página-protegida"
    turnstile_site_key = "0x4XXXXXXXXXXXXXXXXX"  # Encuentre esto en el código fuente de la página

    async with AsyncCamoufox(
        humanize=True,
        headless=False,
        os="windows"
    ) as browser:
        page = await browser.new_page()
        await page.goto(target_url)

        # Esperar a que se cargue Turnstile
        await page.wait_for_selector('input[name="cf-turnstile-response"]', timeout=10000)

        # Resolver el CAPTCHA
        token = await solve_turnstile(turnstile_site_key, target_url)
        print(f"Obtuve el token de Turnstile: {token[:50]}...")

        # Inyectar el token
        await page.evaluate(f'''
            document.querySelector('input[name="cf-turnstile-response"]').value = "{token}";

            // También establecer el callback oculto si está presente
            const callback = document.querySelector('[data-callback]');
            if (callback) {{
                const callbackName = callback.getAttribute('data-callback');
                if (window[callbackName]) {{
                    window[callbackName]('{token}');
                }}
            }}
        ''')

        # Enviar el formulario
        await page.click('button[type="submit"]')
        await page.wait_for_load_state("networkidle")

        print("¡Turnstile evadido con éxito!")


if __name__ == "__main__":
    asyncio.run(main())

Ejemplo 2: Resolver reCAPTCHA v2

python Copy

import asyncio
from camoufox.async_api import AsyncCamoufox

CAPSOLVER_API_KEY = "SU_CLAVE_DE_API"
CAPSOLVER_API = "https://api.capsolver.com"


async def solve_recaptcha_v2(site_key: str, page_url: str) -> str:
    """Resolver reCAPTCHA v2 y devolver el token."""
    import httpx

    async with httpx.AsyncClient() as client:
        # Crear la tarea
        response = await client.post(
            f"{CAPSOLVER_API}/createTask",
            json={
                "clientKey": CAPSOLVER_API_KEY,
                "task": {
                    "type": "ReCaptchaV2TaskProxyLess",
                    "websiteURL": page_url,
                    "websiteKey": site_key,
                }
            }
        )
        result = response.json()

        if result.get("errorId") != 0:
            raise Exception(f"Error: {result.get('errorDescription')}")

        task_id = result["taskId"]

        # Esperar el resultado
        while True:
            result = await client.post(
                f"{CAPSOLVER_API}/getTaskResult",
                json={
                    "clientKey": CAPSOLVER_API_KEY,
                    "taskId": task_id
                }
            )
            data = result.json()

            if data.get("status") == "ready":
                return data["solution"]["gRecaptchaResponse"]
            elif data.get("status") == "failed":
                raise Exception(f"Falló: {data.get('errorDescription')}")

            await asyncio.sleep(2)


async def main():
    target_url = "https://example.com/iniciar-sesión"
    recaptcha_site_key = "6LcXXXXXXXXXXXXXXXXXXXXXXXXX"  # Encuentre en el código fuente de la página

    async with AsyncCamoufox(
        humanize=True,
        headless=False,
        os=["windows", "macos"]  # Selección aleatoria de sistema operativo
    ) as browser:
        page = await browser.new_page()
        await page.goto(target_url)

        # Rellenar campos del formulario con pausas humanas
        await page.fill('input[name="nombre_de_usuario"]', "usuario@ejemplo.com")
        await asyncio.sleep(0.5)  # Pausa similar a la humana
        await page.fill('input[name="contraseña"]', "contraseña123")

        # Resolver el CAPTCHA
        print("Resolviendo reCAPTCHA v2...")
        token = await solve_recaptcha_v2(recaptcha_site_key, target_url)
        print(f"Obtuve el token: {token[:50]}...")

        # Inyectar el token en el campo de respuesta de reCAPTCHA
        await page.evaluate(f'''
            document.getElementById('g-recaptcha-response').innerHTML = '{token}';
            document.getElementById('g-recaptcha-response').style.display = 'block';
        ''')

        # Enviar el formulario
        await page.click('button[type="submit"]')
        await page.wait_for_load_state("networkidle")

        print("¡Inicio de sesión exitoso!")


if __name__ == "__main__":
    asyncio.run(main())

Ejemplo 3: Resolver reCAPTCHA v3

reCAPTCHA v3 es basado en puntuación y no requiere interacción del usuario. Debe especificar el parámetro de acción.

python Copy

import asyncio
from camoufox.async_api import AsyncCamoufox

CAPSOLVER_API_KEY = "SU_CLAVE_DE_API"
CAPSOLVER_API = "https://api.capsolver.com"


async def solve_recaptcha_v3(
    site_key: str,
    page_url: str,
    action: str = "verify",
    min_score: float = 0.7
) -> str:
    """Resolver reCAPTCHA v3 con acción y puntuación mínima especificados."""
    import httpx

    async with httpx.AsyncClient() as client:
        response = await client.post(
            f"{CAPSOLVER_API}/createTask",
            json={
                "clientKey": CAPSOLVER_API_KEY,
                "task": {
                    "type": "ReCaptchaV3TaskProxyLess",
                    "websiteURL": page_url,
                    "websiteKey": site_key,
                    "pageAction": action,
                    "minScore": min_score
                }
            }
        )
        result = response.json()

        if result.get("errorId") != 0:
            raise Exception(f"Error: {result.get('errorDescription')}")

        task_id = result["taskId"]

        while True:
            result = await client.post(
                f"{CAPSOLVER_API}/getTaskResult",
                json={
                    "clientKey": CAPSOLVER_API_KEY,
                    "taskId": task_id
                }
            )
            data = result.json()

            if data.get("status") == "ready":
                return data["solution"]["gRecaptchaResponse"]
            elif data.get("status") == "failed":
                raise Exception(f"Falló: {data.get('errorDescription')}")

            await asyncio.sleep(1)


async def main():
    target_url = "https://example.com/buscar"
    recaptcha_v3_key = "6LcXXXXXXXXXXXXXXXXXXXXXXXXX"

    async with AsyncCamoufox(
        humanize=2.0,  # Máximo 2 segundos de movimientos humanizados
        headless=True,  # Puede ejecutarse en modo sin interfaz para v3
        geoip=True,  # Detectar geolocalización automáticamente desde el proxy
    ) as browser:
        page = await browser.new_page()
        await page.goto(target_url)

        # Resolver reCAPTCHA v3 con acción "buscar"
        print("Resolviendo reCAPTCHA v3...")
        token = await solve_recaptcha_v3(
            recaptcha_v3_key,
            target_url,
            action="buscar",
            min_score=0.9  # Solicitar una alta puntuación
        )

        # Ejecutar la devolución de llamada con el token
        await page.evaluate(f'''
            // Enviar token a través de la devolución de llamada del sitio

grecaptcha.execute('{recaptcha_v3_key}', {action: 'search'})
.then(function(tokenOriginal) {
// Reemplazar con nuestro token resuelto
submitSearch('{token}');
});
''')

Copy

    print("¡reCAPTCHA v3 evadido!")

if name == "main":
asyncio.run(main())

Copy

---

## Mejores prácticas

### 1. Rotación de proxies con GeoIP

Utiliza la función GeoIP de Camoufox para que las huellas dactilares coincidan automáticamente con la ubicación de tu proxy:

```python
async with AsyncCamoufox(
    geoip=True,  # Detectar automáticamente desde la IP del proxy
    proxy={
        "server": "http://proxy.example.com:8080",
        "username": "user",
        "password": "pass"
    }
) as browser:
    # La huella dactilar coincidirá con la ubicación geográfica del proxy
    pass

2. Consistencia de las huellas dactilares

Mantén las huellas dactilares consistentes dentro de una sesión pero rotalas entre sesiones:

python Copy

from browserforge.fingerprints import Screen

# Limitar a tamaños de pantalla comunes
screen = Screen(
    min_width=1280,
    max_width=1920,
    min_height=720,
    max_height=1080
)

async with AsyncCamoufox(
    os="windows",
    screen=screen,
) as browser:
    pass

3. Límites de velocidad

Evita activar límites de velocidad añadiendo retrasos:

python Copy

import random

async def retrasoHumano():
    """Retraso aleatorio para imitar el comportamiento humano."""
    await asyncio.sleep(random.uniform(1.0, 3.0))

# Usar entre acciones
await page.click('button')
await retrasoHumano()
await page.fill('input', 'texto')

4. Manejo de errores

Siempre implementa un manejo adecuado de errores para la resolución de CAPTCHA:

python Copy

async def resolverConReintento(payloadTarea: dict, maxReintentos: int = 3) -> dict:
    """Resolver CAPTCHA con lógica de reintento."""
    for intento in range(maxReintentos):
        try:
            return await resolverCAPTCHA(payloadTarea)
        except TimeoutError:
            if intento < maxReintentos - 1:
                print(f"Tiempo de espera agotado, reintentando... ({intento + 1}/{maxReintentos})")
                await asyncio.sleep(5)
            else:
                raise
        except Exception as e:
            if "saldo" in str(e).lower():
                raise  # No reintentar errores de saldo
            if intento < maxReintentos - 1:
                await asyncio.sleep(2)
            else:
                raise

Bonus: ¡Empieza hoy mismo!

¿Listo para potenciar tu automatización web con Camoufox y CapSolver?

Usa el código CAMOUFOX al registrarte en CapSolver para recibir créditos adicionales!

Este bono exclusivo te ayudará a comenzar con la resolución de CAPTCHA de inmediato.

Conclusión

La integración de Camoufox y CapSolver crea una herramienta poderosa para la automatización web:

Camoufox maneja la detección de bots con suplantación de huellas dactilares a nivel nativo
CapSolver maneja CAPTCHAs con resolución impulsada por inteligencia artificial
Juntos permiten automatización fluida que parece completamente humana

Ya sea que estés construyendo scrapers web, sistemas de pruebas automatizadas o pipelines de recolección de datos, esta combinación ofrece la fiabilidad y el sigilo que necesitas.

Preguntas frecuentes

P: ¿Qué tipos de CAPTCHA funcionan mejor con esta integración?

R: CapSolver admite todos los tipos principales de CAPTCHA. Cloudflare Turnstile y reCAPTCHA v2/v3 tienen las tasas de éxito más altas. La integración funciona sin problemas con cualquier CAPTCHA que CapSolver admita.

P: ¿Puedo usar esto en modo headless?

R: ¡Sí! Camoufox admite el modo headless y mantiene sus capacidades de suplantación de huellas dactilares. Para reCAPTCHA v3 y CAPTCHAs basados en tokens, el modo headless funciona perfectamente. Para CAPTCHAs visibles de v2, el modo con interfaz gráfica puede dar mejores resultados.

P: ¿Cómo encuentro la clave del sitio para un CAPTCHA?

R: Búscalo en el código fuente de la página para:

Turnstile: atributo data-sitekey o elementos cf-turnstile
reCAPTCHA: atributo data-sitekey en el div g-recaptcha

P: ¿Qué hago si la resolución de CAPTCHA falla?

R: Soluciones comunes:

Verifica tu clave de API y tu saldo
Asegúrate de que la clave del sitio sea correcta
Comprueba que la URL de la página coincida con donde aparece el CAPTCHA
Para v3, prueba ajustar el parámetro de acción y el puntaje mínimo
Implementa lógica de reintento con retrasos

P: ¿Camoufox funciona con Selenium?

R: Camoufox está basado en Playwright, no en Selenium. Sin embargo, puedes usar el mismo patrón de integración con cualquier framework de automatización de navegadores.

Ver más

web scrapingApr 22, 2026

Arquitectura de raspado de web para extracción de datos escalable

Aprende una arquitectura de raspado web escalable en Rust con reqwest, scraper, raspado asíncrono, raspado con navegador sin cabeza, rotación de proxies y manejo de CAPTCHA conforme.

Aloísio Vítor

web scrapingFeb 17, 2026

Cómo resolver Captcha en Nanobot con CapSolver

Automatiza la resolución de CAPTCHA con Nanobot y CapSolver. Utiliza Playwright para resolver reCAPTCHA y Cloudflare autónomamente.

Cómo integrar Camoufox con CapSolver para la resolución de CAPTCHA sin interrupciones

Introducción

Objetivos de la integración

¿Qué es Camoufox?

Características clave

Instalación

Uso básico

¿Qué es CapSolver?

Tipos de CAPTCHA soportados

Comenzar con CapSolver

Desafíos previos a la integración

Métodos de integración

Método 1: Integración de API (Recomendado)

Requisitos de configuración

Patrón de integración principal

Método 2: Extensión del navegador

Pasos de instalación

Ejemplos de código

Ejemplo 1: Resolver Cloudflare Turnstile

Ejemplo 2: Resolver reCAPTCHA v2

Ejemplo 3: Resolver reCAPTCHA v3

2. Consistencia de las huellas dactilares

3. Límites de velocidad

4. Manejo de errores

Bonus: ¡Empieza hoy mismo!

Conclusión

Preguntas frecuentes

P: ¿Qué tipos de CAPTCHA funcionan mejor con esta integración?

P: ¿Puedo usar esto en modo headless?

P: ¿Cómo encuentro la clave del sitio para un CAPTCHA?

P: ¿Qué hago si la resolución de CAPTCHA falla?

P: ¿Camoufox funciona con Selenium?

Ver más

Arquitectura de raspado de web para extracción de datos escalable

Cómo resolver Captcha en Nanobot con CapSolver

Cómo integrar Camoufox con CapSolver para la resolución de CAPTCHA sin interrupciones

Introducción

Objetivos de la integración

¿Qué es Camoufox?

Características clave

Instalación

Uso básico

¿Qué es CapSolver?

Tipos de CAPTCHA soportados

Comenzar con CapSolver

Desafíos previos a la integración

Métodos de integración

Método 1: Integración de API (Recomendado)

Requisitos de configuración

Patrón de integración principal

Método 2: Extensión del navegador

Pasos de instalación

Ejemplos de código

Ejemplo 1: Resolver Cloudflare Turnstile

Ejemplo 2: Resolver reCAPTCHA v2

Ejemplo 3: Resolver reCAPTCHA v3

2. Consistencia de las huellas dactilares

3. Límites de velocidad

4. Manejo de errores

Bonus: ¡Empieza hoy mismo!

Conclusión

Preguntas frecuentes

P: ¿Qué tipos de CAPTCHA funcionan mejor con esta integración?

P: ¿Puedo usar esto en modo headless?

P: ¿Cómo encuentro la clave del sitio para un CAPTCHA?

P: ¿Qué hago si la resolución de CAPTCHA falla?

P: ¿Camoufox funciona con Selenium?

Ver más

Arquitectura de raspado de web para extracción de datos escalable

Cómo resolver Captcha en Nanobot con CapSolver

Datos como Servicio (DaaS): ¿Qué es y por qué es importante en 2026

Cómo arreglar errores comunes de raspado de web en 2026